{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 0. Import Libraries"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "!pip install pandas\n",
    "!pip install matplotlib"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import tensorflow as tf\n",
    "import tensorflow.keras as keras\n",
    "from tensorflow.keras import backend as K\n",
    "from tensorflow.keras.layers import *\n",
    "\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from scipy.io import loadmat\n",
    "from scipy.io import savemat\n",
    "import math\n",
    "\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy.random import seed\n",
    "seed(0)\n",
    "tf.random.set_seed(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 1. Define Something in Advance"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 2. Initialize the Grid"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta = 0.05\n",
    "x_domain = np.arange(0, 1+delta, delta)\n",
    "y_domain = np.arange(0, 1+delta, delta)\n",
    "x_mesh,y_mesh = np.meshgrid(x_domain, y_domain)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 3. Define Physical Info."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "k=5\n",
    "governing_equation_components = []\n",
    "governing_equation_components.append(Lambda(lambda x: x[5]))\n",
    "governing_equation_components.append(Lambda(lambda x: x[6]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "governing_equation_mask = x_mesh*0\n",
    "governing_equation_mask[1:-1,1:-1] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "fx = governing_equation_mask*(x_mesh*0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "estimate_equation_form = True\n",
    "#equation_component_combination = [1.0,2.0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 4. Define the Observations"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    suppose: \n",
    "    x = x[0];\n",
    "    y = x[1];\n",
    "    uxy = x[2]; \n",
    "    dudx = x[3];\n",
    "    dudy = x[4];\n",
    "    du2dx2 = x[5];\n",
    "    du2dy2 = x[6];\n",
    "    du2dxdy = x[7];\n",
    "    laplace = x[8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_components = []\n",
    "observation_components.append(Lambda(lambda x: x[2]))\n",
    "observation_components.append(Lambda(lambda x: x[3]))\n",
    "observation_components.append(Lambda(lambda x: x[4]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    format: [x,y,combination,value]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_smooth = loadmat('data.mat')['uxy_list'][-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "truth_data = loadmat('data.mat')['uxy_list'][-1] + np.random.normal(loc=0.0, scale=0.1, size=x_mesh.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(21, 21)"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "truth_data.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "observation_data = []\n",
    "\n",
    "theta_list = np.linspace(0,np.pi*2,800)\n",
    "for theta in theta_list:\n",
    "    x = x_theta(theta)\n",
    "    y = y_theta(theta)\n",
    "    comb = [1,0,0]\n",
    "    v = U(x,y)\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data = []\n",
    "for x,y,v in zip(x_mesh.ravel(),y_mesh.ravel(),truth_data.ravel()):\n",
    "    comb = [1,0,0]\n",
    "    observation_data.append([x,y,comb,v])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 5. Define PICN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]], [[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_x2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-2.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[-1.0/delta]]], [[[1.0/delta]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_y2_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]]], [[[-2.0/delta**2]]], [[[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "def gradient_xy_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[1.0/delta**2]], [[-1.0/delta**2]]], [[[-1.0/delta**2]], [[1.0/delta**2]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "def laplace_kernal_init(shape, dtype=tf.float32):\n",
    "    return tf.constant([[[[0]], [[1.0/delta**2]], [[0]]], [[[1.0/delta**2]], [[-4.0/delta**2]], [[1.0/delta**2]]], [[[0]], [[1.0/delta**2]], [[0]]]], dtype=dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "inputs = [keras.layers.Input(shape=(1,1,1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1)),\n",
    "          keras.layers.Input(shape=(len(observation_data),len(observation_components)*4)),\n",
    "          keras.layers.Input(shape=(len(y_domain),len(x_domain),1))]\n",
    "\n",
    "hidden_field = keras.layers.Conv2DTranspose(filters=1, \n",
    "                                            kernel_size=[len(y_domain)+4,len(x_domain)+4], \n",
    "                                            activation='linear')(inputs[0])\n",
    "coordinates_x = inputs[1]\n",
    "coordinates_y = inputs[2]\n",
    "field = keras.layers.Conv2D(filters=1, \n",
    "                            kernel_size=3, \n",
    "                            padding='valid', \n",
    "                            activation=Lambda(lambda x: x))(hidden_field)\n",
    "gradient_x_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[1,2], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_x_kernal_init)(field)\n",
    "gradient_x2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[1,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_x2_kernal_init)(field)\n",
    "gradient_y_field = keras.layers.Conv2D(filters=1, \n",
    "                                     kernel_size=[2,1], \n",
    "                                     padding='valid',\n",
    "                                     use_bias=False,\n",
    "                                     trainable=False,\n",
    "                                     kernel_initializer=gradient_y_kernal_init)(field)\n",
    "gradient_y2_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,1], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_y2_kernal_init)(field)\n",
    "gradient_xy_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[2,2], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=gradient_xy_kernal_init)(field)\n",
    "laplace_field = keras.layers.Conv2D(filters=1, \n",
    "                                       kernel_size=[3,3], \n",
    "                                       padding='valid',\n",
    "                                       use_bias=False,\n",
    "                                       trainable=False,\n",
    "                                       kernel_initializer=laplace_kernal_init)(field)\n",
    "phycial_fields = [coordinates_x,\n",
    "                  coordinates_y,\n",
    "                  field[:,1:-1,1:-1,:],\n",
    "                  gradient_x_field[:,1:-1,1:,:],\n",
    "                  gradient_y_field[:,1:,1:-1,:],\n",
    "                  gradient_x2_field[:,1:-1,:,:],\n",
    "                  gradient_y2_field[:,:,1:-1,:],\n",
    "                  gradient_xy_field[:,1:,1:,:],\n",
    "                  laplace_field]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "if estimate_equation_form==True:\n",
    "    tf_governing_equation_components = [component(phycial_fields) for component in governing_equation_components]\n",
    "    concat_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_governing_equation_components)\n",
    "    governing_equation = keras.layers.Conv2D(filters=1, \n",
    "                                             kernel_size=[1,1], \n",
    "                                             padding='valid',\n",
    "                                             use_bias=False)(concat_equation_components)*inputs[4]\n",
    "else:\n",
    "    tf_weighted_governing_equation_components = [weight*component(phycial_fields) for [weight,component] in zip(equation_component_combination,governing_equation_components)]\n",
    "    concat_weighted_equation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_weighted_governing_equation_components)\n",
    "    governing_equation = Lambda(lambda x: tf.reduce_sum(x,axis=-1,keepdims=True))(concat_weighted_equation_components)*inputs[4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "tf_observation_components = [component(phycial_fields) for component in observation_components]\n",
    "concat_observation_components = Lambda(lambda x: tf.concat(x,axis=-1))(tf_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_x_position_index_list = []\n",
    "right_x_position_index_list = []\n",
    "left_x_position_weight_list = []\n",
    "right_x_position_weight_list = []\n",
    "\n",
    "bottom_y_position_index_list = []\n",
    "top_y_position_index_list = []\n",
    "bottom_y_position_weight_list = []\n",
    "top_y_position_weight_list = []\n",
    "\n",
    "\n",
    "for data in observation_data:\n",
    "    \n",
    "    left_x_position_index = int(np.floor((data[0] - x_domain[0])/delta))\n",
    "    right_x_position_index = left_x_position_index + 1\n",
    "    left_x_position_weight = 1-(data[0] - (x_domain[0]+delta*left_x_position_index))/delta\n",
    "    right_x_position_weight = 1-left_x_position_weight\n",
    "    \n",
    "    bottom_y_position_index = int(np.floor((data[1] - y_domain[0])/delta))\n",
    "    top_y_position_index = bottom_y_position_index + 1\n",
    "    bottom_y_position_weight = 1-(data[1] - (y_domain[0]+delta*bottom_y_position_index))/delta\n",
    "    top_y_position_weight = 1-bottom_y_position_weight\n",
    "    \n",
    "    if data[0] <= x_domain[0] + 1e-8:\n",
    "        left_x_position_index = 0\n",
    "        right_x_position_index = 1\n",
    "        left_x_position_weight = 1\n",
    "        right_x_position_weight = 0\n",
    "    if data[0] >= x_domain[-1] - 1e-8:\n",
    "        left_x_position_index = len(x_domain)-2\n",
    "        right_x_position_index = len(x_domain)-1\n",
    "        left_x_position_weight = 0\n",
    "        right_x_position_weight = 1\n",
    "    if data[1] <= y_domain[0] + 1e-8:\n",
    "        bottom_y_position_index = 0\n",
    "        top_y_position_index = 1\n",
    "        bottom_y_position_weight = 1\n",
    "        top_y_position_weight = 0\n",
    "    if data[1] >= y_domain[-1] - 1e-8:\n",
    "        bottom_y_position_index = len(y_domain)-2\n",
    "        top_y_position_index = len(y_domain)-1\n",
    "        bottom_y_position_weight = 0\n",
    "        top_y_position_weight = 1\n",
    "    \n",
    "    left_x_position_index_list.append(left_x_position_index)\n",
    "    right_x_position_index_list.append(right_x_position_index)\n",
    "    left_x_position_weight_list.append(left_x_position_weight)\n",
    "    right_x_position_weight_list.append(right_x_position_weight)\n",
    "\n",
    "    bottom_y_position_index_list.append(bottom_y_position_index)\n",
    "    top_y_position_index_list.append(top_y_position_index)\n",
    "    bottom_y_position_weight_list.append(bottom_y_position_weight)\n",
    "    top_y_position_weight_list.append(top_y_position_weight)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "left_bottom_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,bottom_y_position_index_list)])\n",
    "left_top_indices = tf.constant([[0,y,x] for x,y in zip(left_x_position_index_list,top_y_position_index_list)])\n",
    "right_bottom_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,bottom_y_position_index_list)])\n",
    "right_top_indices = tf.constant([[0,y,x] for x,y in zip(right_x_position_index_list,top_y_position_index_list)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_left_bottom_part = Lambda(lambda x: tf.gather_nd(x,left_bottom_indices))(concat_observation_components)\n",
    "observation_data_left_top_part = Lambda(lambda x: tf.gather_nd(x,left_top_indices))(concat_observation_components)\n",
    "observation_data_right_bottom_part = Lambda(lambda x: tf.gather_nd(x,right_bottom_indices))(concat_observation_components)\n",
    "observation_data_right_top_part = Lambda(lambda x: tf.gather_nd(x,right_top_indices))(concat_observation_components)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_four_part = Lambda(lambda x: tf.expand_dims(tf.concat(x,axis=-1),axis=0))([observation_data_left_bottom_part,observation_data_left_top_part,observation_data_right_bottom_part,observation_data_right_top_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_data_interpolation_weights = np.expand_dims(\n",
    "np.asarray([np.concatenate([(np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*left_x_position_weight_list[i]*top_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*bottom_y_position_weight_list[i],\n",
    " (np.asarray([observation_data[i][2][j] for j in range(len(observation_components))]))*right_x_position_weight_list[i]*top_y_position_weight_list[i]],axis=-1) for i in range(len(observation_data))]),\n",
    "    axis=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "observations = Lambda(lambda x: tf.reduce_sum(x[0]*x[1],axis=-1))([inputs[3][0,:,:],observation_data_four_part])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "pde_model = keras.Model(inputs=inputs[:3], outputs=phycial_fields)\n",
    "pde_model_train = keras.Model(inputs=inputs, outputs=[governing_equation,observations])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 6. Prepare the Training Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 1, 1, 1)\n"
     ]
    }
   ],
   "source": [
    "unit_constant = np.asarray([[[[1.0]]]],dtype=np.float32)\n",
    "training_input_data_0 = unit_constant\n",
    "print(training_input_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_1 = np.expand_dims(x_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_2 = np.expand_dims(y_mesh.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441, 12)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_3 = observation_data_interpolation_weights.astype(np.float32)\n",
    "print(training_input_data_3.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_input_data_4 = np.expand_dims(governing_equation_mask.astype(np.float32),axis=[0,-1])\n",
    "print(training_input_data_2.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 21, 21, 1)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_0 = np.expand_dims(fx.astype(np.float32),axis=[0,-1])\n",
    "print(training_label_data_0.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 441)\n"
     ]
    }
   ],
   "source": [
    "training_label_data_1 = np.expand_dims(np.asarray([data[3] for data in observation_data]),axis=[0])\n",
    "print(training_label_data_1.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "training_input_data = [training_input_data_0,training_input_data_1,training_input_data_2,training_input_data_3,training_input_data_4]\n",
    "training_label_data = [training_label_data_0,training_label_data_1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 7. Train the Model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['loss', 'tf_op_layer_Mul_loss', 'lambda_13_loss']\n"
     ]
    }
   ],
   "source": [
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(), loss=\"mse\")\n",
    "pde_model_train.save_weights('picn_initial_weights.h5')\n",
    "temp_history = pde_model_train.fit(x=training_input_data, y=training_label_data, epochs=1, verbose=0)\n",
    "history_keys = []\n",
    "for key in temp_history.history.keys():\n",
    "    history_keys.append(key)\n",
    "print(history_keys)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "def record_predictions():\n",
    "    [_, _, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])\n",
    "    uxy_list.append(uxy[:,:,:,0])\n",
    "    dudx_list.append(dudx[:,:,:,0])\n",
    "    dudy_list.append(dudy[:,:,:,0])\n",
    "    d2udx2_list.append(d2udx2[:,:,:,0])\n",
    "    d2udy2_list.append(d2udy2[:,:,:,0])\n",
    "    d2udxdy_list.append(d2udxdy[:,:,:,0])\n",
    "    laplace_list.append(laplace[:,:,:,0])\n",
    "\n",
    "class Per_X_Epoch_Record(tf.keras.callbacks.Callback):\n",
    "    def __init__(self, record_interval, verbose=1):\n",
    "        super(tf.keras.callbacks.Callback, self).__init__()\n",
    "        self.total_loss = history_keys[0]\n",
    "        self.domain_loss = history_keys[1]\n",
    "        self.bdc_loss = history_keys[2]\n",
    "        self.previous_total_loss = 9999999\n",
    "        self.record_interval = record_interval;\n",
    "        self.verbose = verbose\n",
    "\n",
    "    def on_epoch_end(self, epoch, logs={}):\n",
    "        \n",
    "        if epoch%self.record_interval == 0:\n",
    "            \n",
    "            current_total_loss = logs.get(self.total_loss)\n",
    "            current_domain_loss = logs.get(self.domain_loss)\n",
    "            current_bdc_loss = logs.get(self.bdc_loss)\n",
    "            \n",
    "            epoch_number_list.append(epoch)\n",
    "            total_loss_list.append(current_total_loss)\n",
    "            domain_loss_list.append(current_domain_loss)\n",
    "            boundary_loss_list.append(current_bdc_loss)\n",
    "        \n",
    "            if current_total_loss < self.previous_total_loss:\n",
    "                self.previous_total_loss = current_total_loss\n",
    "                pde_model_train.save_weights('picn_best_weights.h5')\n",
    "            \n",
    "            if self.verbose > 0:\n",
    "                print(\"epoch: {:10.5f} | total_loss: {:10.5f} | domain_loss: {:10.5f} | bdc_loss: {:10.5f}\".format(epoch,current_total_loss,current_domain_loss,current_bdc_loss))\n",
    "        \n",
    "            # evaluate the errors in f-domain\n",
    "            record_predictions()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "callbacks = [\n",
    "    Per_X_Epoch_Record(record_interval=200,verbose=1),\n",
    "]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch:    0.00000 | total_loss:    6.14916 | domain_loss:  557.84418 | bdc_loss:    0.57648\n",
      "epoch:  200.00000 | total_loss:    0.89506 | domain_loss:   38.97425 | bdc_loss:    0.51042\n",
      "epoch:  400.00000 | total_loss:    0.53836 | domain_loss:    8.76535 | bdc_loss:    0.45526\n",
      "epoch:  600.00000 | total_loss:    0.43528 | domain_loss:    3.48947 | bdc_loss:    0.40443\n",
      "epoch:  800.00000 | total_loss:    0.37115 | domain_loss:    1.89715 | bdc_loss:    0.35574\n",
      "epoch: 1000.00000 | total_loss:    0.31910 | domain_loss:    1.20689 | bdc_loss:    0.31013\n",
      "epoch: 1200.00000 | total_loss:    0.27647 | domain_loss:    0.81225 | bdc_loss:    0.27105\n",
      "epoch: 1400.00000 | total_loss:    0.24542 | domain_loss:    0.55233 | bdc_loss:    0.24232\n",
      "epoch: 1600.00000 | total_loss:    0.22657 | domain_loss:    0.38260 | bdc_loss:    0.22500\n",
      "epoch: 1800.00000 | total_loss:    0.21700 | domain_loss:    0.27935 | bdc_loss:    0.21637\n",
      "epoch: 2000.00000 | total_loss:    0.21236 | domain_loss:    0.22001 | bdc_loss:    0.21228\n",
      "epoch: 2200.00000 | total_loss:    0.20956 | domain_loss:    0.18850 | bdc_loss:    0.20977\n",
      "epoch: 2400.00000 | total_loss:    0.20723 | domain_loss:    0.17570 | bdc_loss:    0.20755\n",
      "epoch: 2600.00000 | total_loss:    0.20490 | domain_loss:    0.17648 | bdc_loss:    0.20519\n",
      "epoch: 2800.00000 | total_loss:    0.20243 | domain_loss:    0.18801 | bdc_loss:    0.20257\n",
      "epoch: 3000.00000 | total_loss:    0.19971 | domain_loss:    0.20895 | bdc_loss:    0.19962\n",
      "epoch: 3200.00000 | total_loss:    0.19667 | domain_loss:    0.23910 | bdc_loss:    0.19624\n",
      "epoch: 3400.00000 | total_loss:    0.19323 | domain_loss:    0.27919 | bdc_loss:    0.19236\n",
      "epoch: 3600.00000 | total_loss:    0.18928 | domain_loss:    0.33070 | bdc_loss:    0.18786\n",
      "epoch: 3800.00000 | total_loss:    0.18471 | domain_loss:    0.39578 | bdc_loss:    0.18258\n",
      "epoch: 4000.00000 | total_loss:    0.17938 | domain_loss:    0.47704 | bdc_loss:    0.17638\n",
      "epoch: 4200.00000 | total_loss:    0.17314 | domain_loss:    0.57709 | bdc_loss:    0.16905\n",
      "epoch: 4400.00000 | total_loss:    0.16582 | domain_loss:    0.69775 | bdc_loss:    0.16045\n",
      "epoch: 4600.00000 | total_loss:    0.15732 | domain_loss:    0.83851 | bdc_loss:    0.15044\n",
      "epoch: 4800.00000 | total_loss:    0.14760 | domain_loss:    0.99447 | bdc_loss:    0.13904\n",
      "epoch: 5000.00000 | total_loss:    0.13673 | domain_loss:    1.15457 | bdc_loss:    0.12645\n",
      "epoch: 5200.00000 | total_loss:    0.12501 | domain_loss:    1.30168 | bdc_loss:    0.11312\n",
      "epoch: 5400.00000 | total_loss:    0.11292 | domain_loss:    1.41630 | bdc_loss:    0.09976\n",
      "epoch: 5600.00000 | total_loss:    0.10118 | domain_loss:    1.48377 | bdc_loss:    0.08721\n",
      "epoch: 5800.00000 | total_loss:    0.09055 | domain_loss:    1.50175 | bdc_loss:    0.07629\n",
      "epoch: 6000.00000 | total_loss:    0.08168 | domain_loss:    1.48193 | bdc_loss:    0.06754\n",
      "epoch: 6200.00000 | total_loss:    0.07485 | domain_loss:    1.44343 | bdc_loss:    0.06102\n",
      "epoch: 6400.00000 | total_loss:    0.06988 | domain_loss:    1.40291 | bdc_loss:    0.05641\n",
      "epoch: 6600.00000 | total_loss:    0.06634 | domain_loss:    1.36907 | bdc_loss:    0.05319\n",
      "epoch: 6800.00000 | total_loss:    0.06375 | domain_loss:    1.34357 | bdc_loss:    0.05083\n",
      "epoch: 7000.00000 | total_loss:    0.06171 | domain_loss:    1.32479 | bdc_loss:    0.04896\n",
      "epoch: 7200.00000 | total_loss:    0.05995 | domain_loss:    1.31076 | bdc_loss:    0.04732\n",
      "epoch: 7400.00000 | total_loss:    0.05829 | domain_loss:    1.30025 | bdc_loss:    0.04574\n",
      "epoch: 7600.00000 | total_loss:    0.05661 | domain_loss:    1.29228 | bdc_loss:    0.04412\n",
      "epoch: 7800.00000 | total_loss:    0.05479 | domain_loss:    1.28372 | bdc_loss:    0.04238\n",
      "epoch: 8000.00000 | total_loss:    0.05272 | domain_loss:    1.26825 | bdc_loss:    0.04045\n",
      "epoch: 8200.00000 | total_loss:    0.05036 | domain_loss:    1.24116 | bdc_loss:    0.03833\n",
      "epoch: 8400.00000 | total_loss:    0.04744 | domain_loss:    1.18024 | bdc_loss:    0.03600\n",
      "epoch: 8600.00000 | total_loss:    0.04385 | domain_loss:    1.08273 | bdc_loss:    0.03335\n",
      "epoch: 8800.00000 | total_loss:    0.04025 | domain_loss:    0.96757 | bdc_loss:    0.03088\n",
      "epoch: 9000.00000 | total_loss:    0.03650 | domain_loss:    0.82146 | bdc_loss:    0.02857\n",
      "epoch: 9200.00000 | total_loss:    0.03181 | domain_loss:    0.61736 | bdc_loss:    0.02589\n",
      "epoch: 9400.00000 | total_loss:    0.02776 | domain_loss:    0.47233 | bdc_loss:    0.02327\n",
      "epoch: 9600.00000 | total_loss:    0.02442 | domain_loss:    0.36128 | bdc_loss:    0.02102\n",
      "epoch: 9800.00000 | total_loss:    0.02152 | domain_loss:    0.27942 | bdc_loss:    0.01891\n",
      "epoch: 10000.00000 | total_loss:    0.01919 | domain_loss:    0.22508 | bdc_loss:    0.01711\n",
      "epoch: 10200.00000 | total_loss:    0.01749 | domain_loss:    0.18819 | bdc_loss:    0.01576\n",
      "epoch: 10400.00000 | total_loss:    0.01614 | domain_loss:    0.15951 | bdc_loss:    0.01470\n",
      "epoch: 10600.00000 | total_loss:    0.01496 | domain_loss:    0.13512 | bdc_loss:    0.01375\n",
      "epoch: 10800.00000 | total_loss:    0.01385 | domain_loss:    0.11265 | bdc_loss:    0.01285\n",
      "epoch: 11000.00000 | total_loss:    0.01275 | domain_loss:    0.09165 | bdc_loss:    0.01195\n",
      "epoch: 11200.00000 | total_loss:    0.01174 | domain_loss:    0.07571 | bdc_loss:    0.01109\n",
      "epoch: 11400.00000 | total_loss:    0.01099 | domain_loss:    0.06546 | bdc_loss:    0.01044\n",
      "epoch: 11600.00000 | total_loss:    0.01043 | domain_loss:    0.06096 | bdc_loss:    0.00992\n",
      "epoch: 11800.00000 | total_loss:    0.01006 | domain_loss:    0.05996 | bdc_loss:    0.00955\n",
      "epoch: 12000.00000 | total_loss:    0.00963 | domain_loss:    0.04842 | bdc_loss:    0.00924\n",
      "epoch: 12200.00000 | total_loss:    0.00901 | domain_loss:    0.02903 | bdc_loss:    0.00881\n",
      "epoch: 12400.00000 | total_loss:    0.00846 | domain_loss:    0.01817 | bdc_loss:    0.00836\n",
      "epoch: 12600.00000 | total_loss:    0.00806 | domain_loss:    0.01164 | bdc_loss:    0.00802\n",
      "epoch: 12800.00000 | total_loss:    0.00778 | domain_loss:    0.00746 | bdc_loss:    0.00779\n",
      "epoch: 13000.00000 | total_loss:    0.00762 | domain_loss:    0.00613 | bdc_loss:    0.00763\n",
      "epoch: 13200.00000 | total_loss:    0.00750 | domain_loss:    0.00299 | bdc_loss:    0.00754\n",
      "epoch: 13400.00000 | total_loss:    0.00744 | domain_loss:    0.00216 | bdc_loss:    0.00749\n",
      "epoch: 13600.00000 | total_loss:    0.00740 | domain_loss:    0.00147 | bdc_loss:    0.00746\n",
      "epoch: 13800.00000 | total_loss:    0.00739 | domain_loss:    0.00130 | bdc_loss:    0.00745\n",
      "epoch: 14000.00000 | total_loss:    0.00738 | domain_loss:    0.00155 | bdc_loss:    0.00744\n",
      "epoch: 14200.00000 | total_loss:    0.00738 | domain_loss:    0.00103 | bdc_loss:    0.00744\n",
      "epoch: 14400.00000 | total_loss:    0.00737 | domain_loss:    0.00100 | bdc_loss:    0.00744\n",
      "epoch: 14600.00000 | total_loss:    0.00738 | domain_loss:    0.00167 | bdc_loss:    0.00744\n",
      "epoch: 14800.00000 | total_loss:    0.00737 | domain_loss:    0.00098 | bdc_loss:    0.00744\n",
      "epoch: 15000.00000 | total_loss:    0.00738 | domain_loss:    0.00163 | bdc_loss:    0.00744\n",
      "epoch: 15200.00000 | total_loss:    0.00737 | domain_loss:    0.00098 | bdc_loss:    0.00744\n",
      "epoch: 15400.00000 | total_loss:    0.00737 | domain_loss:    0.00100 | bdc_loss:    0.00744\n",
      "epoch: 15600.00000 | total_loss:    0.00737 | domain_loss:    0.00106 | bdc_loss:    0.00744\n",
      "epoch: 15800.00000 | total_loss:    0.00737 | domain_loss:    0.00099 | bdc_loss:    0.00744\n",
      "epoch: 16000.00000 | total_loss:    0.00738 | domain_loss:    0.00138 | bdc_loss:    0.00744\n",
      "epoch: 16200.00000 | total_loss:    0.00738 | domain_loss:    0.00131 | bdc_loss:    0.00744\n",
      "epoch: 16400.00000 | total_loss:    0.00738 | domain_loss:    0.00137 | bdc_loss:    0.00744\n",
      "epoch: 16600.00000 | total_loss:    0.00737 | domain_loss:    0.00111 | bdc_loss:    0.00744\n",
      "epoch: 16800.00000 | total_loss:    0.00738 | domain_loss:    0.00132 | bdc_loss:    0.00744\n",
      "epoch: 17000.00000 | total_loss:    0.00737 | domain_loss:    0.00103 | bdc_loss:    0.00744\n",
      "epoch: 17200.00000 | total_loss:    0.00737 | domain_loss:    0.00105 | bdc_loss:    0.00744\n",
      "epoch: 17400.00000 | total_loss:    0.00737 | domain_loss:    0.00106 | bdc_loss:    0.00744\n",
      "epoch: 17600.00000 | total_loss:    0.00737 | domain_loss:    0.00106 | bdc_loss:    0.00744\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "epoch: 17800.00000 | total_loss:    0.00737 | domain_loss:    0.00128 | bdc_loss:    0.00744\n",
      "epoch: 18000.00000 | total_loss:    0.00737 | domain_loss:    0.00108 | bdc_loss:    0.00744\n",
      "epoch: 18200.00000 | total_loss:    0.00737 | domain_loss:    0.00110 | bdc_loss:    0.00743\n",
      "epoch: 18400.00000 | total_loss:    0.00737 | domain_loss:    0.00112 | bdc_loss:    0.00743\n",
      "epoch: 18600.00000 | total_loss:    0.00737 | domain_loss:    0.00114 | bdc_loss:    0.00743\n",
      "epoch: 18800.00000 | total_loss:    0.00737 | domain_loss:    0.00149 | bdc_loss:    0.00743\n",
      "epoch: 19000.00000 | total_loss:    0.00737 | domain_loss:    0.00120 | bdc_loss:    0.00743\n",
      "epoch: 19200.00000 | total_loss:    0.00737 | domain_loss:    0.00136 | bdc_loss:    0.00743\n",
      "epoch: 19400.00000 | total_loss:    0.00737 | domain_loss:    0.00128 | bdc_loss:    0.00743\n",
      "epoch: 19600.00000 | total_loss:    0.00737 | domain_loss:    0.00179 | bdc_loss:    0.00743\n",
      "epoch: 19800.00000 | total_loss:    0.00737 | domain_loss:    0.00139 | bdc_loss:    0.00743\n"
     ]
    }
   ],
   "source": [
    "epoch_number_list = []\n",
    "total_loss_list = []\n",
    "domain_loss_list = []\n",
    "boundary_loss_list = []\n",
    "uxy_list = []\n",
    "dudx_list = []\n",
    "dudy_list = []\n",
    "d2udx2_list = []\n",
    "d2udy2_list = []\n",
    "d2udxdy_list = []\n",
    "laplace_list = []\n",
    "pde_model_train.load_weights('picn_initial_weights.h5')\n",
    "pde_model_train.compile(optimizer=keras.optimizers.Adam(learning_rate=0.0002), loss=\"mse\", loss_weights = [0.01, 0.99])\n",
    "pde_model_train.fit(x=training_input_data, \n",
    "                    y=training_label_data, \n",
    "                    epochs=20000, verbose=0,\n",
    "                    callbacks=callbacks)\n",
    "pde_model_train.load_weights('picn_best_weights.h5')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 8. LOSS"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 864x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "df=pd.DataFrame({'epoch': epoch_number_list, \n",
    "                 'total_loss': total_loss_list, \n",
    "                 'governing_loss': domain_loss_list, \n",
    "                 'boundary_loss': boundary_loss_list})\n",
    "\n",
    "plt.figure(figsize=(12, 4))\n",
    "plt.plot( 'epoch', 'total_loss', data=df, marker='o', markerfacecolor='red', markersize=2, color='skyblue', linewidth=3)\n",
    "plt.plot( 'epoch', 'governing_loss', data=df, marker='', color='green', linewidth=2, linestyle='dashed')\n",
    "plt.plot( 'epoch', 'boundary_loss', data=df, marker='', color='blue', linewidth=2, linestyle='dashed')\n",
    "plt.legend()\n",
    "#plt.xscale('log')\n",
    "plt.yscale('log')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x_m, y_m, uxy, dudx, dudy, d2udx2, d2udy2, d2udxdy, laplace] = pde_model.predict(training_input_data[:3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 9. Results overview"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Text(0.5, 1.0, 'smooth')"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1296x216 with 8 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, axs = plt.subplots(1,4,constrained_layout=False, figsize=(18, 3))\n",
    "#\n",
    "ax = axs.ravel()[0]\n",
    "temp = uxy[0,:,:,0]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0],20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('prediction')\n",
    "#\n",
    "ax = axs.ravel()[1]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('truth')\n",
    "#\n",
    "ax = axs.ravel()[2]\n",
    "cs = ax.contourf(x_domain, y_domain, uxy[0,:,:,0]-truth_data,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('error')\n",
    "#\n",
    "ax = axs.ravel()[3]\n",
    "cs = ax.contourf(x_domain, y_domain, truth_smooth,20)\n",
    "fig.colorbar(cs, ax=ax, shrink=0.9)\n",
    "ax.set_xlabel('x')\n",
    "ax.set_ylabel('y')\n",
    "ax.set_title('smooth')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<tf.Variable 'conv2d_7/kernel:0' shape=(1, 1, 2, 1) dtype=float32, numpy=\n",
       " array([[[[0.12901515],\n",
       "          [0.6607924 ]]]], dtype=float32)>]"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.99776625"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.19955325*5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 10. Save the Process Data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "picn_process_data = {'x_domain':x_domain,\n",
    "                     'y_domain':y_domain,\n",
    "                     'epoch_number_list':np.asarray(epoch_number_list),\n",
    "                     'total_loss_list':np.asarray(total_loss_list),\n",
    "                     'domain_loss_list':np.asarray(domain_loss_list),\n",
    "                     'boundary_loss_list':np.asarray(boundary_loss_list),\n",
    "                     'truth_data':np.asarray(truth_data),\n",
    "                     'uxy_list':np.concatenate(uxy_list,axis=0),\n",
    "                     'dudx_list':np.concatenate(dudx_list,axis=0),\n",
    "                     'dudy_list':np.concatenate(dudy_list,axis=0),\n",
    "                     'd2udx2_list':np.concatenate(d2udx2_list,axis=0),\n",
    "                     'd2udy2_list':np.concatenate(d2udy2_list,axis=0),\n",
    "                     'd2udxdy_list':np.concatenate(d2udxdy_list,axis=0),\n",
    "                     'laplace_list':np.concatenate(laplace_list,axis=0),\n",
    "                     'k1':pde_model_train.layers[-6].weights[0][0,0,0,0].numpy(),\n",
    "                     'k2':pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()}\n",
    "savemat('picn_process_data.mat', picn_process_data)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.12901515"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6607924"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.1218204"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()/pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.4364089965820312"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(pde_model_train.layers[-6].weights[0][0,0,1,0].numpy()/pde_model_train.layers[-6].weights[0][0,0,0,0].numpy()-5)/5*100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
